package erabbit.net.camerabot;

import android.Manifest;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.media.AudioManager;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.SurfaceHolder;
import android.view.View;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.baidu.idl.face.platform.FaceConfig;
import com.baidu.idl.face.platform.FaceSDKManager;
import com.baidu.idl.face.platform.ui.FaceSDKResSettings;
import com.baidu.tts.auth.AuthInfo;
//import com.baidu.tts.client.SpeechSynthesizer;
import com.baidu.tts.client.TtsMode;
import com.facepp.library.util.ConUtil;
import com.facepp.library.util.DialogUtil;
import com.facepp.library.util.Util;
import com.iflytek.cloud.ErrorCode;
import com.iflytek.cloud.InitListener;
import com.iflytek.cloud.SpeechConstant;
import com.iflytek.cloud.SpeechError;
import com.iflytek.cloud.SpeechSynthesizer;
import com.iflytek.cloud.SpeechUtility;
import com.iflytek.cloud.SynthesizerListener;
import com.iflytek.sunflower.FlowerCollector;
import com.megvii.facepp.sdk.Facepp;
import com.megvii.licensemanager.sdk.LicenseManager;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import erabbit.net.camerabot.control.InitConfig;
import erabbit.net.camerabot.control.MySyntherizer;
import erabbit.net.camerabot.control.NonBlockSyntherizer;
import erabbit.net.camerabot.control.OfflineResource;
import erabbit.net.camerabot.utils.FileUtils;

public class CamerBotActivity extends Activity implements CameraPreview.FaceCallback {

    public static final String TAG = CamerBotActivity.class.getSimpleName();
    public static final String DETECT_CONFIG = "FaceOptions";

    // View
    protected View mRootView;
    protected CameraPreview mSurfaceView;
    protected SurfaceHolder mSurfaceHolder;
    protected TextView mTipsView;
    protected LinearLayout mImageLayout;
    ImageView mFaceOverlayView;
    // 人脸信息
    protected FaceConfig mFaceConfig;
    // 显示Size
    protected int mDisplayWidth = 0;
    protected int mDisplayHeight = 0;
    // 状态标识
    // 相机
    // 监听系统音量广播
    protected BroadcastReceiver mVolumeReceiver;
    Handler handler = new Handler();
    Facepp facepp;

    boolean startDetect = true;
    boolean startTakePicture = false;
    boolean startCountDown = false;
    boolean isFirst = true;
    boolean isResume = false;
    TextView countdown;
    int countdownTime;


    // 百度语音 //////////////////////////////////////////////////////////////

    protected MySyntherizer synthesizer;
    private static final String TEXT = "大家好，需要拍照吗？我可以给你们拍哦";
    private static final String TEXT_10S = "大家摆好姿势，十秒后开始拍照哦";

    // ================== 初始化参数设置开始 ==========================
    /**
     * 发布时请替换成自己申请的appId appKey 和 secretKey。注意如果需要离线合成功能,请在您申请的应用中填写包名。
     * 本demo的包名是com.baidu.tts.sample，定义在build.gradle中。
     */
//    private String appId = "8535996";
//    private String appKey = "MxPpf3nF5QX0pndKKhS7IXcB";
//    private String secretKey = "7226e84664474aa098296da5eb2aa434";
    private String appId = "10254996";
    private String appKey = "NvyRrz4Hg80S76dg8ZQ8K2fB";
    private String secretKey = "ZdmTeiFpjZH0oUkN18ddfgDeKoZsHLgt";

    // TtsMode.MIX; 离在线融合，在线优先； TtsMode.ONLINE 纯在线； 没有纯离线
    //private TtsMode ttsMode = TtsMode.MIX;
    private TtsMode ttsMode = TtsMode.ONLINE;

    // 离线发音选择，VOICE_FEMALE即为离线女声发音。
    // assets目录下bd_etts_speech_female.data为离线男声模型；bd_etts_speech_female.data为离线女声模型
    protected String offlineVoice = OfflineResource.VOICE_MALE;

    // ================选择TtsMode.ONLINE  不需要设置以下参数; 选择TtsMode.MIX 需要设置下面2个离线资源文件的路径
    private static String TEMP_DIR = "/sdcard/baiduTTS"; //重要！请手动将assets目录下的3个dat 文件复制到该目录

    private static String TEXT_FILENAME = TEMP_DIR + "/" + "bd_etts_text.dat"; // 请确保该PATH下有这个文件

    private static String MODEL_FILENAME = TEMP_DIR + "/" + "bd_etts_speech_male.dat"; // 请确保该PATH下有这个文件 male是男声 female女声

    // ===============初始化参数设置完毕，更多合成参数请至getParams()方法中设置 =================

    protected SpeechSynthesizer mSpeechSynthesizer;

    // =========== 以下为UI部分 ==================================================
    // private Button mSpeak, mStop;

    //private TextView mShowText;

    protected Handler mainHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (msg.obj != null) {
                print(msg.obj.toString());
            }
        }
    };

    private static final String DESC = "精简版合成，仅给出示例集成合成的调用过程。可以测试离线合成功能，首次使用请联网。\n" +
            "其中initTTS方法需要在新线程调用，否则引起UI阻塞。\n" +
            "纯在线请修改代码里ttsMode为TtsMode.ONLINE， 没有纯离线。\n" +
            "离线功能需要手动将assets目录下的资源文件复制到TEMP_DIR =/sdcard/baiduTTS \n" +
            "完整的SDK调用方式可以参见MainActivity\n\n";
    /////////////////////////////////////////////////////////////////////////////


    /////////////讯飞//////////////////
    // 语音合成对象
    private SpeechSynthesizer mTts;

    // 默认发音人
    private String voicer = "xiaoyan";

    private String[] mCloudVoicersEntries;
    private String[] mCloudVoicersValue ;

    // 缓冲进度
    private int mPercentForBuffering = 0;
    // 播放进度
    private int mPercentForPlaying = 0;


    // 引擎类型
    private String mEngineType = SpeechConstant.TYPE_CLOUD;

    private Toast mToast;
    final int detectRate = 20;
    int curNum = 0;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        setContentView(R.layout.activity_camer_bot);
        DisplayMetrics dm = new DisplayMetrics();
        Display display = this.getWindowManager().getDefaultDisplay();
        display.getMetrics(dm);
        mDisplayWidth = dm.widthPixels;
        mDisplayHeight = dm.heightPixels;

        FaceSDKResSettings.initializeResId();
        mFaceConfig = FaceSDKManager.getInstance().getFaceConfig();
        mFaceOverlayView = (ImageView) findViewById(R.id.detect_surface_overlay);
        mRootView = this.findViewById(R.id.detect_root_layout);
        mSurfaceView = (CameraPreview) findViewById(R.id.detect_surface_view);
        countdown = (TextView) findViewById(R.id.countdown);
        countdown.setVisibility(View.INVISIBLE);
        mSurfaceView.setFaceCallback(this);
        mSurfaceHolder = mSurfaceView.getHolder();
        mSurfaceHolder.setSizeFromLayout();
        mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

        ////语音////

        SpeechUtility.createUtility(this, SpeechConstant.APPID +"=5a050c29");

        //initView();
        //initPermission();
        //initTTs();
        ///////////
       // initIfy();
        network();
        mainHandler.postDelayed(new Runnable() {
            @Override
            public void run() {

                if (isFirst) {
                    initIfy();
                    isFirst = false;
                } else {
                    if (startDetect && isResume) {
                        speak(TEXT);
                    } else {
                        if (!startCountDown) {
                            stop();
                        }
                    }
                }
                handler.postDelayed(this, 1000 * 15);
            }
        }, 2000); //每隔1s执行

    }


    void initIfy(){
        // 初始化合成对象
        mTts = SpeechSynthesizer.createSynthesizer(this, mTtsInitListener);
        mEngineType = SpeechConstant.TYPE_CLOUD;
    }

    @Override
    protected void onResume() {
        //移动数据统计分析 讯飞
        FlowerCollector.onResume(CamerBotActivity.this);
        FlowerCollector.onPageStart(TAG);

        super.onResume();
        isResume = true;
        startDetect = true;
        startTakePicture = false;
        countdownTime = 15;
        countdown.setVisibility(View.INVISIBLE);

    }


    private void network() {

        if (Util.API_KEY == null || Util.API_SECRET == null) {
            if (!ConUtil.isReadKey(this)) {
                DialogUtil mDialogUtil = new DialogUtil(this);
                mDialogUtil.showDialog(getResources().getString(R.string.key_secret));
            }
        }

        if (Facepp.getSDKAuthType(ConUtil.getFileContent(this, R.raw
                .megviifacepp_0_4_7_model)) == 2) {// 非联网授权
            //authState(true);
            return;
        }

        final LicenseManager licenseManager = new LicenseManager(this);
        licenseManager.setExpirationMillis(Facepp.getApiExpirationMillis(this, ConUtil.getFileContent(this, R.raw
                .megviifacepp_0_4_7_model)));

        String uuid = ConUtil.getUUIDString(CamerBotActivity.this);
        long apiName = Facepp.getApiName();

        licenseManager.setAuthTimeBufferMillis(0);

        licenseManager.takeLicenseFromNetwork(uuid, Util.API_KEY, Util.API_SECRET, apiName,
                LicenseManager.DURATION_30DAYS, "Landmark", "1", true, new LicenseManager.TakeLicenseCallback() {
                    @Override
                    public void onSuccess() {
                        //authState(true);
                        //授权成功
                        Log.i(TAG, "授权成功");
                        facepp = new Facepp();
                        String error = facepp.init(CamerBotActivity.this, ConUtil.getFileContent(CamerBotActivity.this, R.raw.megviifacepp_0_4_7_model));
                        if (error != null) {
                            Log.e("initError", error);
                        }
                        Facepp.FaceppConfig config = facepp.getFaceppConfig();
                        config.minFaceSize = 120;
                        config.interval = 2000;

                        config.one_face_tracking = 1;
                        config.rotation = 0;
                        config.roi_left = 0;
                        config.roi_top = 0;
                        config.roi_bottom = 480;
                        config.roi_right = 640;
                        config.detectionMode = Facepp.FaceppConfig.DETECTION_MODE_NORMAL;

//                        byte[] dataT = null;
//                        Bitmap bitmapT = BitmapFactory.decodeResource(getResources(), R.drawable.test2);
//                        ByteArrayOutputStream baos = new ByteArrayOutputStream();
//                        bitmapT.compress(Bitmap.CompressFormat.JPEG, 100, baos);
//                        dataT = baos.toByteArray();
//                        dataT = ConUtil.getGrayscale(bitmapT);
//                        Facepp.Face[] faces = facepp.detect(dataT, bitmapT.getWidth(), bitmapT.getHeight(), Facepp.IMAGEMODE_GRAY);
//
//                        if (faces != null) {
//                            Log.i(TAG, "faces.length=" + faces.length);
//                        }
                    }

                    @Override
                    public void onFailed(int i, byte[] bytes) {
                        //authState(false);
                    }
                });
    }


    @Override
    public void callback(final Bitmap bitmap) {

        if (facepp != null) {

            if (startDetect) {
                //if (false) {
                curNum++;
                if (curNum % detectRate == 0) {
                    curNum = 0;
                } else {
                    return;
                }

                new Thread(new Runnable() {
                    @Override
                    public void run() {

                        byte[] dataT = ConUtil.getGrayscale(bitmap);
                        Facepp.Face[] faces = facepp.detect(dataT, bitmap.getWidth(), bitmap.getHeight(), Facepp.IMAGEMODE_GRAY);
                        //Facepp.Face[] faces = new Facepp.Face[]{new Facepp.Face()};
                        //检测到人脸后
                        if (faces != null && faces.length > 0) {
                            startDetect = false;
                            startCountDown = true;
                            speak(TEXT_10S);
                            Log.e(TAG, "faces.length=" + faces.length);
                            handler.postDelayed(new Runnable() {
                                @Override
                                public void run() {

                                    countdownTime--;
                                    if (countdownTime <= 10) {
                                        countdown.setVisibility(View.VISIBLE);
                                        countdown.setText(String.valueOf(countdownTime));
                                    }

                                    if (countdownTime == 0) {
                                        startTakePicture = true;
                                        startCountDown = false;

                                    } else {
                                        handler.postDelayed(this, 1000 * 1);
                                    }
                                }
                            }, 0); //每隔1s执行
                        }
                    }

                }).start();
            }

            if (startTakePicture) {
                Bitmap newBitmap = FileUtils.waterTextMark(CamerBotActivity.this, bitmap, "酷图软件");
                MyApplication.bmp = newBitmap;
                final String picUrl = FileUtils.saveBitmap(newBitmap);
                Intent intent = new Intent(CamerBotActivity.this, ShowImageActivity.class);
                intent.putExtra("picUrl", picUrl);
                startActivity(intent);
                startTakePicture = false;
            }
        }
    }



    /**
     * 百度语音部分
     */

    /**
     * 注意此处为了说明流程，故意在UI线程中调用。
     * 实际集成中，该方法一定在新线程中调用，并且该线程不能结束。具体可以参考NonBlockSyntherizer的写法
     */
    private void initTTs() {

        Map<String, String> params = getParams();
        // appId appKey secretKey 网站上您申请的应用获取。注意使用离线合成功能的话，需要应用中填写您app的包名。包名在build.gradle中获取。
        InitConfig initConfig = new InitConfig(appId, appKey, secretKey, ttsMode, offlineVoice, params, null);
        synthesizer = new NonBlockSyntherizer(this, initConfig, mainHandler); // 此处可以改为MySyntherizer 了解调用过程
    }


    /**
     * 合成的参数，可以初始化时填写，也可以在合成前设置。
     *
     * @return
     */
    protected Map<String, String> getParams() {
        Map<String, String> params = new HashMap<String, String>();
//        // 以下参数均为选填
//        params.put(SpeechSynthesizer.PARAM_SPEAKER, "0"); // 设置在线发声音人： 0 普通女声（默认） 1 普通男声 2 特别男声 3 情感男声<度逍遥> 4 情感儿童声<度丫丫>
//        params.put(SpeechSynthesizer.PARAM_VOLUME, "5"); // 设置合成的音量，0-9 ，默认 5
//        params.put(SpeechSynthesizer.PARAM_SPEED, "5");// 设置合成的语速，0-9 ，默认 5
//        params.put(SpeechSynthesizer.PARAM_PITCH, "5");// 设置合成的语调，0-9 ，默认 5
//        params.put(SpeechSynthesizer.PARAM_MIX_MODE, SpeechSynthesizer.MIX_MODE_DEFAULT);         // 该参数设置为TtsMode.MIX生效。即纯在线模式不生效。
//        // MIX_MODE_DEFAULT 默认 ，wifi状态下使用在线，非wifi离线。在线状态下，请求超时6s自动转离线
//        // MIX_MODE_HIGH_SPEED_SYNTHESIZE_WIFI wifi状态下使用在线，非wifi离线。在线状态下， 请求超时1.2s自动转离线
//        // MIX_MODE_HIGH_SPEED_NETWORK ， 3G 4G wifi状态下使用在线，其它状态离线。在线状态下，请求超时1.2s自动转离线
//        // MIX_MODE_HIGH_SPEED_SYNTHESIZE, 2G 3G 4G wifi状态下使用在线，其它状态离线。在线状态下，请求超时1.2s自动转离线
        return params;
    }


    /**
     * 检查 TEXT_FILENAME, MODEL_FILENAME 这2个文件是否存在，不存在请自行从assets目录里手动复制
     *
     * @return
     */
    private boolean checkOfflineResources() {
        String[] filenames = {TEXT_FILENAME, MODEL_FILENAME};
        for (String path : filenames) {
            File f = new File(path);
            if (!f.canRead()) {
                print("[ERROR] 文件不存在或者不可读取，请从assets目录复制改文件到：" + path);
                return false;
            }
        }
        return true;
    }

    private void speak(String text) {
        /* 以下参数每次合成时都可以修改
         *  mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_SPEAKER, "0"); // 设置在线发声音人： 0 普通女声（默认） 1 普通男声 2 特别男声 3 情感男声<度逍遥> 4 情感儿童声<度丫丫>
         *  mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_VOLUME, "5"); // 设置合成的音量，0-9 ，默认 5
         *  mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_SPEED, "5");// 设置合成的语速，0-9 ，默认 5
         *  mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_PITCH, "5");// 设置合成的语调，0-9 ，默认 5
         *
         *  mSpeechSynthesizer.setParam(SpeechSynthesizer.PARAM_MIX_MODE, SpeechSynthesizer.MIX_MODE_DEFAULT);
         *  // MIX_MODE_DEFAULT 默认 ，wifi状态下使用在线，非wifi离线。在线状态下，请求超时6s自动转离线
         * // MIX_MODE_HIGH_SPEED_SYNTHESIZE_WIFI wifi状态下使用在线，非wifi离线。在线状态下， 请求超时1.2s自动转离线
         *  // MIX_MODE_HIGH_SPEED_NETWORK ， 3G 4G wifi状态下使用在线，其它状态离线。在线状态下，请求超时1.2s自动转离线
         * // MIX_MODE_HIGH_SPEED_SYNTHESIZE, 2G 3G 4G wifi状态下使用在线，其它状态离线。在线状态下，请求超时1.2s自动转离线
         */

        //mShowText.setText("");
        if (synthesizer != null) {
            int result = synthesizer.speak(text);
            checkResult(result, "speak");
        }

        if(mTts!=null){
            FlowerCollector.onEvent(this, "tts_play");

            // 设置参数
            setParam();
            int code = mTts.startSpeaking(text, mTtsListener);
//			/**
//			 * 只保存音频不进行播放接口,调用此接口请注释startSpeaking接口
//			 * text:要合成的文本，uri:需要保存的音频全路径，listener:回调接口
//			*/
//			String path = Environment.getExternalStorageDirectory()+"/tts.pcm";
//			int code = mTts.synthesizeToUri(text, path, mTtsListener);
            Log.d(TAG,"开始合成code="+code);
            if (code != ErrorCode.SUCCESS) {
                showTip("语音合成失败,错误码: " + code);
            }
        }

    }

    private void stop() {
        if (synthesizer != null) {
            print("停止合成引擎 按钮已经点击");
            int result = synthesizer.stop();
            checkResult(result, "stop");
        }

        if(mTts!=null){
            Log.d(TAG,"停止合成引擎 ");
            mTts.stopSpeaking();
        }
    }


    private void print(String message) {
        Log.i(TAG, message);
        //mShowText.append(message + "\n");
    }

    @Override
    protected void onDestroy() {

        if (synthesizer != null) {
            synthesizer.release();
        }

        if( null != mTts ){
            mTts.stopSpeaking();
            // 退出时释放连接
            mTts.destroy();
        }
        super.onDestroy();
    }

    private void checkResult(int result, String method) {
        if (result != 0) {
            print("error code :" + result + " method:" + method + ", 错误码文档:http://yuyin.baidu.com/docs/tts/122 ");
        }
    }

    //  下面是android 6.0以上的动态授权

    /**
     * android 6.0 以上需要动态申请权限
     */
    private void initPermission() {
        String permissions[] = {
                Manifest.permission.INTERNET,
                Manifest.permission.ACCESS_NETWORK_STATE,
                Manifest.permission.MODIFY_AUDIO_SETTINGS,
                Manifest.permission.WRITE_EXTERNAL_STORAGE,
                Manifest.permission.WRITE_SETTINGS,
                Manifest.permission.READ_PHONE_STATE,
                Manifest.permission.ACCESS_WIFI_STATE,
                Manifest.permission.CHANGE_WIFI_STATE
        };

        ArrayList<String> toApplyList = new ArrayList<String>();

        for (String perm : permissions) {
            if (PackageManager.PERMISSION_GRANTED != ContextCompat.checkSelfPermission(this, perm)) {
                toApplyList.add(perm);
                //进入到这里代表没有权限.
            }
        }
        String tmpList[] = new String[toApplyList.size()];
        if (!toApplyList.isEmpty()) {
            ActivityCompat.requestPermissions(this, toApplyList.toArray(tmpList), 123);
        }

    }


    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        // 此处为android 6.0以上动态授权的回调，用户自行实现。
    }

    /////////////讯飞语音///////


    /**
     * 初始化监听。
     */
    private InitListener mTtsInitListener = new InitListener() {
        @Override
        public void onInit(int code) {
            Log.d(TAG, "InitListener init() code = " + code);
            if (code != ErrorCode.SUCCESS) {
                showTip("初始化失败,错误码："+code);
            } else {
                // 初始化成功，之后可以调用startSpeaking方法
                // 注：有的开发者在onCreate方法中创建完合成对象之后马上就调用startSpeaking进行合成，
                // 正确的做法是将onCreate中的startSpeaking调用移至这里
            }
        }
    };

    /**
     * 合成回调监听。
     */
    private SynthesizerListener mTtsListener = new SynthesizerListener() {

        @Override
        public void onSpeakBegin() {
            showTip("开始播放");
        }

        @Override
        public void onSpeakPaused() {
            showTip("暂停播放");
        }

        @Override
        public void onSpeakResumed() {
            showTip("继续播放");
        }

        @Override
        public void onBufferProgress(int percent, int beginPos, int endPos,
                                     String info) {
            // 合成进度
            mPercentForBuffering = percent;
            showTip("合成进度="+mPercentForBuffering);
        }

        @Override
        public void onSpeakProgress(int percent, int beginPos, int endPos) {
            // 播放进度
            mPercentForPlaying = percent;
            showTip("播放进度="+mPercentForPlaying);
        }

        @Override
        public void onCompleted(SpeechError error) {
            if (error == null) {
                showTip("播放完成");
            } else if (error != null) {
                showTip(error.getPlainDescription(true));
            }
        }

        @Override
        public void onEvent(int eventType, int arg1, int arg2, Bundle obj) {
            // 以下代码用于获取与云端的会话id，当业务出错时将会话id提供给技术支持人员，可用于查询会话日志，定位出错原因
            // 若使用本地能力，会话id为null
            //	if (SpeechEvent.EVENT_SESSION_ID == eventType) {
            //		String sid = obj.getString(SpeechEvent.KEY_EVENT_SESSION_ID);
            //		Log.d(TAG, "session id =" + sid);
            //	}
        }
    };

    private void showTip(final String str) {
        mToast.setText(str);
        mToast.show();
    }

    /**
     * 参数设置
     * @return
     */
    private void setParam(){
        // 清空参数
        mTts.setParameter(SpeechConstant.PARAMS, null);
        // 根据合成引擎设置相应参数
        if(mEngineType.equals(SpeechConstant.TYPE_CLOUD)) {
            mTts.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_CLOUD);
            // 设置在线合成发音人
            mTts.setParameter(SpeechConstant.VOICE_NAME, voicer);
            //设置合成语速
            mTts.setParameter(SpeechConstant.SPEED,  "50");
            //设置合成音调
            mTts.setParameter(SpeechConstant.PITCH, "50");
            //设置合成音量
            mTts.setParameter(SpeechConstant.VOLUME, "50");
        }else {
            mTts.setParameter(SpeechConstant.ENGINE_TYPE, SpeechConstant.TYPE_LOCAL);
            // 设置本地合成发音人 voicer为空，默认通过语记界面指定发音人。
            mTts.setParameter(SpeechConstant.VOICE_NAME, "");
            /**
             * TODO 本地合成不设置语速、音调、音量，默认使用语记设置
             * 开发者如需自定义参数，请参考在线合成参数设置
             */
        }
        //设置播放器音频流类型
        mTts.setParameter(SpeechConstant.STREAM_TYPE, "3");
        // 设置播放合成音频打断音乐播放，默认为true
        mTts.setParameter(SpeechConstant.KEY_REQUEST_FOCUS, "true");

        // 设置音频保存路径，保存音频格式支持pcm、wav，设置路径为sd卡请注意WRITE_EXTERNAL_STORAGE权限
        // 注：AUDIO_FORMAT参数语记需要更新版本才能生效
        mTts.setParameter(SpeechConstant.AUDIO_FORMAT, "wav");
        mTts.setParameter(SpeechConstant.TTS_AUDIO_PATH, Environment.getExternalStorageDirectory()+"/msc/tts.wav");
    }


    @Override
    protected void onPause() {
        //移动数据统计分析
        FlowerCollector.onPageEnd(TAG);
        FlowerCollector.onPause(CamerBotActivity.this);
        super.onPause();
        isResume = false;
        if( null != mTts ) {
            mTts.stopSpeaking();
        }
    }
    

}
